home *** CD-ROM | disk | FTP | other *** search
/ FishMarket 1.0 / FishMarket v1.0.iso / fishies / 526-550 / disk_530 / dme / src.lzh / src / subs.c < prev    next >
C/C++ Source or Header  |  1991-06-26  |  7KB  |  409 lines
  1.  
  2. /*
  3.  *  SUBS.C
  4.  *
  5.  *    (C)Copyright 1987 by Matthew Dillon, All Rights Reserved
  6.  *
  7.  *  Subroutines.
  8.  */
  9.  
  10. #include "defs.h"
  11.  
  12. Prototype void makemygadget (struct Gadget *);
  13. Prototype int firstns (char *);
  14. Prototype int lastns (char *);
  15. Prototype int wordlen (char *);
  16. Prototype int getpathto (BPTR, char *, char *);
  17. Prototype void *allocb (int);
  18. Prototype void *allocl (int);
  19. Prototype void bmovl (void *, void *, long);
  20. Prototype int detab (char *, char *, int);
  21. Prototype int xefgets (FILE *, char *, int);
  22. Prototype int ncstrcmp (unsigned char *, unsigned char *);
  23. Prototype struct _ED *finded (char *, int);
  24. Prototype void mountrequest(int);
  25. Prototype int DeadKeyConvert(struct IntuiMessage *, UBYTE *, int, struct KeyMap *);
  26. Prototype FONT * GetFont(char *, short);
  27. Prototype char *GetDEnv(char *);
  28. Prototype void SetDEnv(char *, char *);
  29.  
  30. Prototype extern __stkargs int arpreq (char *, char *, char *, WIN *);
  31.  
  32. Prototype extern void *clrmem(void *, size_t);
  33.  
  34.  
  35. typedef struct FileInfoBlock FIB;
  36. typedef struct Process         PROC;
  37.  
  38. extern void *OpenFont();
  39. extern void *OpenDiskFont();
  40. extern void *OpenLibrary();
  41.  
  42. /*
  43.  *  Create DME's text icon.
  44.  */
  45.  
  46. void
  47. makemygadget(gad)
  48. struct Gadget *gad;
  49. {
  50.     static unsigned long ga[] = {
  51.     0xFFFFFFFF,    /* 32 pixels across */
  52.     0x80FDCBFD,
  53.     0xFFFDDFFD,
  54.     0x80000001,
  55.     0x80DFDDDF,
  56.     0x80000001,
  57.     0xBC0EF00B,
  58.     0x80000001,
  59.     0xBFC00CDD,
  60.     0x80000001,
  61.     0xA00DF00F,
  62.     0x80000001,
  63.     0x80000001,
  64.  
  65.     0x80000001,
  66.     0x80FDCBFD,
  67.     0xFFFDDFFD,
  68.     0x80000001,
  69.     0x80DFDDDF,
  70.     0x80000001,
  71.     0xBC0EF00B,
  72.     0x80000001,
  73.     0xBFC00CDD,
  74.     0x80000001,
  75.     0xA00DF00F,
  76.     0x80000001,
  77.     0xFFFFFFFF
  78.     };
  79.     static struct Image image = {
  80.     0, 0, 20, 16, 2, (unsigned short *)ga, 3, 0, NULL
  81.     };
  82.     clrmem(gad, sizeof(struct Gadget));
  83.     gad->Width = 20;
  84.     gad->Height = 17;
  85.     gad->Flags    = GADGIMAGE|GADGHCOMP;
  86.     gad->GadgetType   = BOOLGADGET;
  87.     gad->Activation = RELVERIFY|GADGIMMEDIATE;
  88.     gad->GadgetRender = (APTR)ℑ
  89. }
  90.  
  91. /*
  92.  * return index of first non space.  Returns 0 if no spaces found.
  93.  */
  94.  
  95. firstns(str)
  96. char *str;
  97. {
  98.     short i;
  99.  
  100.     for (i = 0; str[i] && str[i] == ' '; ++i);
  101.     if (str[i] == 0)
  102.     i = 0;
  103.     return((int)i);
  104. }
  105.  
  106. /*
  107.  *  Return index of last non-space, 0 if no spaces.
  108.  */
  109.  
  110. lastns(str)
  111. char *str;
  112. {
  113.     short i;
  114.  
  115.     for (i = strlen(str) - 1; i > 0 && str[i] == ' '; --i);
  116.     if (i < 0)
  117.     i = 0;
  118.     return((int)i);
  119. }
  120.  
  121. /*
  122.  *  Return length of word under cursor
  123.  */
  124.  
  125. wordlen(str)
  126. char *str;
  127. {
  128.     short i;
  129.  
  130.     for (i = 0; *str && *str != ' '; ++i, ++str);
  131.     return((int)i);
  132. }
  133.  
  134. /*
  135.  *  Backtracks the program lock, 0 on failure, 1 on success.
  136.  */
  137.  
  138. getpathto(lock, arg0, buf)
  139. BPTR lock;
  140. char *arg0;
  141. char *buf;
  142. {
  143.     FIB *fib;
  144.     BPTR parLock = NULL;
  145.     int r = 0;
  146.     short lastDir = 0;
  147.  
  148.     buf[0] = 0;
  149.     if (fib = malloc(sizeof(FIB))) {
  150.     r = 1;
  151.     while (lock) {
  152.         fib->fib_FileName[0] = 0;
  153.         if (Examine(lock, fib) == 0)
  154.         r = 0;
  155.         if (parLock) {
  156.         parLock = ParentDir(lock);
  157.         UnLock(lock);
  158.         } else {
  159.         parLock = ParentDir(lock);
  160.         if (fib->fib_DirEntryType > 0)
  161.             lastDir = 1;
  162.         }
  163.         if (parLock == NULL)
  164.         strins(buf, ":");
  165.         strins(buf, fib->fib_FileName);
  166.         lock = parLock;
  167.     }
  168.     free(fib);
  169.     if (lastDir == 1) {
  170.         short len;
  171.         if ((len = strlen(buf)) && buf[len-1] != ':')
  172.         strcat(buf, "/");
  173.         strcat(buf, arg0);
  174.     }
  175.     }
  176.     return(r);
  177. }
  178.  
  179. /*
  180.  *  Allocation routines and other shortcuts
  181.  */
  182.  
  183. void *
  184. allocb(bytes)
  185. {
  186.     return(AllocMem(bytes, MEMF_CLEAR|MEMF_PUBLIC));
  187. }
  188.  
  189. void *
  190. allocl(lwords)
  191. {
  192.     return(AllocMem(lwords<<2, MEMF_CLEAR|MEMF_PUBLIC));
  193. }
  194.  
  195. void
  196. bmovl(s,d,n)
  197. void *s, *d;
  198. long n;
  199. {
  200.     movmem(s, d, n << 2);
  201. }
  202.  
  203. /*
  204.  *  Remove tabs in a buffer
  205.  */
  206.  
  207. detab(ibuf, obuf, maxlen)
  208. char *ibuf, *obuf;
  209. {
  210.     short i, j;
  211.  
  212.     maxlen -= 2;
  213.     for (i = j = 0; ibuf[i] && j < maxlen; ++i) {
  214.     if (ibuf[i] == 9) {
  215.         do {
  216.         obuf[j++] = ' ';
  217.         } while ((j & 7) && j < maxlen);
  218.     } else {
  219.         obuf[j++] = ibuf[i];
  220.     }
  221.     }
  222.     if (j && obuf[j-1] == '\n')
  223.     --j;
  224.     while (j && obuf[j-1] == ' ')
  225.     --j;
  226.     obuf[j] = 0;
  227.     return((int)j);
  228. }
  229.  
  230. xefgets(fi, buf, max)
  231. FILE *fi;
  232. char *buf;
  233. int max;
  234. {
  235.     char ebuf[256];
  236.  
  237.     if (fgets(ebuf, max, fi))
  238.     return(detab(ebuf, buf, max));
  239.     return(-1);
  240. }
  241.  
  242. ncstrcmp(s1, s2)
  243. ubyte *s1, *s2;
  244. {
  245.     ubyte c1, c2;
  246.  
  247.     for (;;) {
  248.     c1 = *s1;
  249.     c2 = *s2;
  250.     if (c1 >= 'A' && c1 <= 'Z') c1 |= 0x20;
  251.     if (c2 >= 'A' && c2 <= 'Z') c2 |= 0x20;
  252.     if (c1 != c2)
  253.         break;
  254.     if ((c1|c2) == 0)
  255.         return(0);
  256.     ++s1;
  257.     ++s2;
  258.     }
  259.     if (c1 < c2)
  260.     return(-1);
  261.     if (c1 > c2)
  262.     return(1);
  263. }
  264.  
  265. ED *
  266. finded(str, doff)
  267. char *str;
  268. {
  269.     ED *ed;
  270.  
  271.     for (ed = (ED *)DBase.mlh_Head; ed->Node.mln_Succ; ed = (ED *)ed->Node.mln_Succ) {
  272.     if (strlen(ed->Name) >= doff && ncstrcmp(str, ed->Name+doff) == 0)
  273.         return(ed);
  274.     }
  275.     return(NULL);
  276. }
  277.  
  278. void
  279. mountrequest(bool)
  280. int bool;
  281. {
  282.     static APTR original_pr_WindowPtr = NULL;
  283.     register PROC *proc;
  284.  
  285.     proc = (PROC *)FindTask(0);
  286.     if (!bool && proc->pr_WindowPtr != (APTR)-1) {
  287.     original_pr_WindowPtr = proc->pr_WindowPtr;
  288.     proc->pr_WindowPtr = (APTR)-1;
  289.     }
  290.     if (bool && proc->pr_WindowPtr == (APTR)-1)
  291.     proc->pr_WindowPtr = original_pr_WindowPtr;
  292. }
  293.  
  294. char *
  295. GetDEnv(ename)
  296. char *ename;
  297. {
  298.     long envLock = Lock("env:", SHARED_LOCK);
  299.     char *str = NULL;
  300.  
  301.     if (envLock) {
  302.     long oldLock = CurrentDir(envLock);
  303.     FILE *fi = fopen(ename, "r");
  304.     long siz;
  305.     if (fi) {
  306.         fseek(fi, 0L, 2);
  307.         siz = ftell(fi);
  308.         fseek(fi, 0L, 0);
  309.         if (siz > 0 && (str = malloc(siz + 1))) {
  310.         fread(str, siz, 1, fi);
  311.         str[siz] = 0;
  312.         }
  313.         fclose(fi);
  314.     }
  315.     UnLock(CurrentDir(oldLock));
  316.     }
  317.     return(str);
  318. }
  319.  
  320. void
  321. SetDEnv(ename, econt)
  322. char *ename;
  323. char *econt;
  324. {
  325.     long envLock = Lock("env:", SHARED_LOCK);
  326.  
  327.     if (envLock) {
  328.     long oldLock = CurrentDir(envLock);
  329.     FILE *fi = fopen(ename, "w");
  330.  
  331.     if (fi) {
  332.         fwrite(econt, strlen(econt), 1, fi);
  333.         fclose(fi);
  334.     }
  335.     UnLock(CurrentDir(oldLock));
  336.     }
  337. }
  338.  
  339.  
  340. /*
  341.  *  GETFONT()
  342.  *
  343.  *  This function properly searches resident and disk fonts for the
  344.  *  font.
  345.  */
  346.  
  347. struct Library *DiskfontBase;
  348.  
  349. FONT *
  350. GetFont(name, size)
  351. char *name;
  352. short size;
  353. {
  354.     FONT *font1;
  355.     TA Ta;
  356.     short libwasopen = (DiskfontBase != (void *)NULL);
  357.  
  358.     Ta.ta_Name    = (UBYTE *)name;
  359.     Ta.ta_YSize = size;
  360.     Ta.ta_Style = 0;
  361.     Ta.ta_Flags = 0;
  362.  
  363.     font1 = OpenFont(&Ta);
  364.     if (font1 == NULL || font1->tf_YSize != Ta.ta_YSize) {
  365.     FONT *font2;
  366.  
  367.     if (libwasopen || (DiskfontBase = OpenLibrary("diskfont.library", 0))) {
  368.         if (font2 = OpenDiskFont(&Ta)) {
  369.         if (font1)
  370.             CloseFont(font1);
  371.         font1 = font2;
  372.         }
  373.         if (libwasopen == 0)
  374.         CloseLibrary(DiskfontBase);
  375.     }
  376.     }
  377.     return(font1);
  378. }
  379.  
  380. /*
  381.  *  DEAD.C
  382.  */
  383.  
  384. int
  385. DeadKeyConvert(msg,buf,bufsize,keymap)
  386. struct IntuiMessage *msg;
  387. UBYTE *buf;
  388. int bufsize;
  389. struct KeyMap *keymap;
  390. {
  391.     static struct InputEvent ievent = { NULL, IECLASS_RAWKEY };
  392.     if (msg->Class != RAWKEY)
  393.     return(-2);
  394.     ievent.ie_Code = msg->Code;
  395.     ievent.ie_Qualifier = msg->Qualifier;
  396.     ievent.ie_position.ie_addr = *((APTR *)msg->IAddress);
  397.     return(RawKeyConvert(&ievent,(char *)buf,bufsize,keymap));
  398. }
  399.  
  400. void *
  401. clrmem(ptr, bytes)
  402. void *ptr;
  403. long bytes;
  404. {
  405.     setmem(ptr, bytes, 0);
  406.     return(ptr);
  407. }
  408.  
  409.